/* 
一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。
给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。


输入： [1,2,3,1]
输出： 4
解释： 选择 1 号预约和 3 号预约，总时长 = 1 + 3 = 4。


思路：因为后续预约由前面的决定(不能相邻)，考虑动态规划

声明一个记录数组，记录到前多少个预约的总时间，
找到初始值：dp[0]=1,dp[1]=2  即为数组的一二项
找到第n项与前面的关系： dp[n]=dp[n-2]

*/
/**
 * @param {number[]} nums
 * @return {number}
 */
var massage = function (nums) {
    // const n = nums.length
    // let dp = []
    // dp[0] = nums[0], dp[1] = nums[1]
    // if (n <= 2) {
    //     if (n == 0) return 0
    //     if (n == 1) return dp[0]
    //     return dp[0] > dp[1] ? dp[0] : dp[1]
    // } else {
    //     for (let i = 2; i < n + 1; i++) {
    //         // console.log(dp);
    //         dp[i] = dp[i - 2] + nums[i]
    //     }
    //     return dp[n - 1] > dp[n - 2] ? dp[n - 1] : dp[n - 2]
    // }

    const dp = [];
    dp[0] = 0;
    dp[1] = 0;

    for (let i = 2; i < nums.length + 2; i++) {
        dp[i] = Math.max(dp[i - 2] + nums[i - 2], dp[i - 1]);
        console.log(dp);
    }
    return dp[nums.length + 1];

};

let nums = [1, 3, 1, 2]

let res = massage(nums)
console.log(res);

/* public int massage(int[] nums) {
    int n = nums.length;
    if (n == 0) {
        return 0;
    }
    int dp0 = 0, dp1 = nums[0];

    for (int i = 1; i < n; ++i){
        tdp0 = Math.max(dp0, dp1); // 计算 dp[i][0]
        tdp1 = dp0 + nums[i]; // 计算 dp[i][1]

        dp0 = tdp0; // 用 dp[i][0] 更新 dp_0
        dp1 = tdp1; // 用 dp[i][1] 更新 dp_1
    }
    return Math.max(dp0, dp1);
} */